/**
 * 日期时间工具函数
 */

/**
 * 格式化日期时间为字符串
 * @param {Date|string} date - 日期对象或可解析的日期字符串
 * @param {string} [format='YYYY-MM-DD HH:mm:ss'] - 格式字符串
 * @returns {string} 格式化后的日期字符串
 */
export function formatDate(date, format = 'YYYY-MM-DD HH:mm:ss') {
    if (!date) return ''

    let d = date
    if (typeof d === 'string') {
        // 处理ISO格式日期字符串
        if (d.includes('T')) {
            d = d.replace('T', ' ').split('.')[0]
        }
        d = new Date(d)
    }

    if (!(d instanceof Date) || isNaN(d.getTime())) {
        return ''
    }

    const pad = (num) => num.toString().padStart(2, '0')

    const replacements = {
        YYYY: d.getFullYear(),
        MM: pad(d.getMonth() + 1),
        DD: pad(d.getDate()),
        HH: pad(d.getHours()),
        mm: pad(d.getMinutes()),
        ss: pad(d.getSeconds())
    }

    return format.replace(
        /YYYY|MM|DD|HH|mm|ss/g,
        (match) => replacements[match]
    )
}

/**
 * 将日期字符串转换为Date对象
 * @param {string} dateStr - 日期字符串
 * @returns {Date} 转换后的Date对象
 */
export function parseDate(dateStr) {
    if (!dateStr) return null

    // 处理ISO格式
    if (dateStr.includes('T')) {
        return new Date(dateStr)
    }

    // 处理常见的日期时间格式
    const patterns = [
        /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/, // YYYY-MM-DD HH:mm:ss
        /^(\d{4})-(\d{2})-(\d{2})$/,                          // YYYY-MM-DD
        /^(\d{4})\/(\d{2})\/(\d{2}) (\d{2}):(\d{2}):(\d{2})$/, // YYYY/MM/DD HH:mm:ss
        /^(\d{4})\/(\d{2})\/(\d{2})$/                          // YYYY/MM/DD
    ]

    for (const pattern of patterns) {
        const match = dateStr.match(pattern)
        if (match) {
            const [, year, month, day, hour = 0, minute = 0, second = 0] = match
            return new Date(year, month - 1, day, hour, minute, second)
        }
    }

    // 尝试用Date原生解析
    const date = new Date(dateStr)
    return isNaN(date.getTime()) ? null : date
}

/**
 * 计算两个日期之间的天数差
 * @param {Date|string} date1 - 第一个日期
 * @param {Date|string} date2 - 第二个日期
 * @returns {number} 天数差（date2 - date1）
 */
export function daysBetween(date1, date2) {
    const d1 = typeof date1 === 'string' ? parseDate(date1) : date1
    const d2 = typeof date2 === 'string' ? parseDate(date2) : date2

    if (!d1 || !d2) return 0

    const diffTime = d2.getTime() - d1.getTime()
    return Math.floor(diffTime / (1000 * 60 * 60 * 24))
}

/**
 * 将秒数格式化为天时分秒
 * @param {number} seconds - 秒数
 * @returns {string} 格式化后的字符串（如 "2天 3小时 5分钟"）
 */
export function formatDuration(seconds) {
    if (!seconds || seconds < 0) return '0秒'

    const days = Math.floor(seconds / (3600 * 24))
    const hours = Math.floor((seconds % (3600 * 24)) / 3600)
    const mins = Math.floor((seconds % 3600) / 60)
    const secs = seconds % 60

    const parts = []
    if (days > 0) parts.push(`${days}天`)
    if (hours > 0) parts.push(`${hours}小时`)
    if (mins > 0) parts.push(`${mins}分钟`)
    if (secs > 0 || parts.length === 0) parts.push(`${secs}秒`)

    return parts.join(' ')
}

/**
 * 获取当前时间戳（秒）
 * @returns {number} 当前时间戳（秒）
 */
export function getCurrentTimestamp() {
    return Math.floor(Date.now() / 1000)
}

/**
 * 将时间戳转换为日期字符串
 * @param {number} timestamp - 时间戳（秒）
 * @param {string} [format='YYYY-MM-DD HH:mm:ss'] - 格式字符串
 * @returns {string} 格式化后的日期字符串
 */
export function timestampToDate(timestamp, format = 'YYYY-MM-DD HH:mm:ss') {
    if (!timestamp) return ''
    return formatDate(new Date(timestamp * 1000), format)
}

/**
 * 检查日期是否在有效范围内
 * @param {Date|string} date - 要检查的日期
 * @param {Date|string} minDate - 最小日期
 * @param {Date|string} maxDate - 最大日期
 * @returns {boolean} 是否在范围内
 */
export function isDateInRange(date, minDate, maxDate) {
    const d = typeof date === 'string' ? parseDate(date) : date
    const min = typeof minDate === 'string' ? parseDate(minDate) : minDate
    const max = typeof maxDate === 'string' ? parseDate(maxDate) : maxDate

    if (!d) return false

    if (min && d < min) return false
    if (max && d > max) return false

    return true
}

/**
 * 获取日期的开始时间（00:00:00）
 * @param {Date} date - 日期对象
 * @returns {Date} 当天的开始时间
 */
export function getStartOfDay(date) {
    const d = new Date(date)
    d.setHours(0, 0, 0, 0)
    return d
}

/**
 * 获取日期的结束时间（23:59:59）
 * @param {Date} date - 日期对象
 * @returns {Date} 当天的结束时间
 */
export function getEndOfDay(date) {
    const d = new Date(date)
    d.setHours(23, 59, 59, 999)
    return d
}

export default {
    formatDate,
    parseDate,
    daysBetween,
    formatDuration,
    getCurrentTimestamp,
    timestampToDate,
    isDateInRange,
    getStartOfDay,
    getEndOfDay
}